package cn.demoncat.util.mybatis.base;

import cn.demoncat.util.lang.MapUtil;
import cn.demoncat.util.lang.ParamEmptyUtil;
import cn.demoncat.util.lang.ParamValidUtil;
import cn.demoncat.util.lang.constant.LongConstant;
import cn.demoncat.util.lang.constant.StatusConstant.Common;
import cn.demoncat.util.lang.constant.StringConstant;
import cn.demoncat.util.lang.entity.report.SidCountVo;
import cn.demoncat.util.lang.entity.Result;
import cn.demoncat.util.lang.entity.report.SidCountSum;
import cn.demoncat.util.lang.entity.report.*;
import cn.demoncat.util.mybatis.constant.MapperConstant;
import cn.demoncat.util.lang.constant.ReportConstant;
import cn.demoncat.util.lang.constant.ReportConstant.Dimension;
import cn.demoncat.util.lang.constant.ReportConstant.ModePeriod;
import cn.demoncat.util.lang.constant.ReportConstant.ModeTime;
import cn.demoncat.util.lang.ReportUtil;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;

import java.io.Serializable;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

/**
 * 报表数据ServiceImpl
 *
 * @author 延晓磊
 *
 * @since 2017年3月26日
 */
public abstract class BaseReportServiceImpl<T extends BaseReportEntity<T, P>, P extends Serializable> extends BaseServiceImpl<T, P> implements BaseReportService<T, P> {

	/**
	 * 初始化DAO
	 */
	protected abstract BaseReportDao<T, P> getDao();

	/**
	 * 插入报表：自动填充统计日期数据
	 * 
	 * @param o
	 * @param param	图表插入的查询+填充参数：ReportParamSave.build(mode)
	 * 
	 * @author 延晓磊
	 *
	 * @since 2019年12月11日
	 */
	@Override
	public void saveReport(T o, ReportParamSave param) {
		// 填充参数
		o.fillTimes(param);
		// 保存
		this.save(o);
	}

	/**
	 * 插入报表：自动填充统计日期数据
	 * 
	 * @param os
	 * @param param	图表插入的查询+填充参数：ReportParamSave.build(mode)
	 * 
	 * @author 延晓磊
	 *
	 * @since 2019年12月11日
	 */
	@Override
	public void saveReport(List<T> os, ReportParamSave param) {
		// 填充参数
		for (T o : os) {
			o.fillTimes(param);
		}
		// 保存
		this.batchSave(os);
	}
	
	/**
	 * 统计 - 总数
	 * 
	 * @param condition
	 * @return SUM(count)
	 * 
	 * @author 延晓磊
	 *
	 * @since 2019年10月19日
	 */
	@Override
	public long countCount(Map<String, Object> condition) {
		return getDao().countCount(condition);
	}
	
	/**
	 * 统计 - 维度:总数
	 * 
	 * @param condition
	 * 
	 * @return {id:item, count:SUM(count)}
	 * 
	 * @author 延晓磊
	 *
	 * @since 2019年10月19日
	 */
	@Override
	public List<SidCountVo> countCountByItem(Map<String, Object> condition) {
		return countCountByItem(condition,null);
	}
	
	/**
	 * 统计 - 维度:总数
	 * 
	 * @param condition
	 * @param itemMap	维度映射（只返回映射的数据）
	 * 
	 * @return {id:item, name: itemMap[item], count:SUM(count)}
	 * 
	 * @author 延晓磊
	 *
	 * @since 2019年10月19日
	 */
	@Override
	public List<SidCountVo> countCountByItem(Map<String, Object> condition, Map<String,String> itemMap) {
		// 分组
		if (condition == null) {
			condition = new HashMap<>();
		}
		condition.put(MapperConstant.ParamName.GROUP_COLUMNS, ReportConstant.Column.ITEM.getGroupColumns());
		// 查询
		List<T> datas = this.chartCount(condition);
		// 整合
		List<SidCountVo> counts = new ArrayList<>();
		SidCountVo count;
		if (MapUtil.isEmpty(itemMap)) {
			// 所有查询结果
			for (T data : datas) {
				count = new SidCountVo();
				count.setId(data.getItem());
				count.setCount(data.getCount());
				counts.add(count);
			}
		}else {
			// 指定映射结果
			for (Entry<String, String> item : itemMap.entrySet()) {
				count = new SidCountVo();
				count.setId(item.getKey());
				count.setName(item.getValue());
				count.setCount(LongConstant.N0);
				for (T data : datas) {
					if (item.getKey().equals(data.getItem())) {
						count.setCount(data.getCount());
						break;
					}
				}
				counts.add(count);
			}
		}
		return counts;
	}
	
	/**
	 * 统计 - 维度:总数
	 * 
	 * @param condition
	 * 
	 * @return {id:item, name:title, count:SUM(count)}
	 * 
	 * @author 延晓磊
	 *
	 * @since 2019年10月19日
	 */
	@Override
	public List<SidCountVo> countCountByItemTitle(Map<String, Object> condition) {
		// 分组
		if (condition == null) {
			condition = new HashMap<>();
		}
		condition.put(MapperConstant.ParamName.GROUP_COLUMNS, ReportConstant.Column.ITEM_TITLE.getGroupColumns());
		// 查询
		List<T> datas = this.chartCount(condition);
		// 整合
		List<SidCountVo> counts = new ArrayList<>(datas.size());
		SidCountVo count;
		for (T data : datas) {
			count = new SidCountVo();
			count.setId(data.getItem());
			count.setName(data.getTitle());
			count.setCount(data.getCount());
			counts.add(count);
		}
		return counts;
	}
	
	/**
	 * 统计 - 总额
	 * 
	 * @param condition
	 * @return SUM(sum)
	 * 
	 * @author 延晓磊
	 *
	 * @since 2019年10月19日
	 */
	@Override
	public BigDecimal countSum(Map<String, Object> condition) {
		return getDao().countSum(condition);
	}

	/**
	 * 统计 - 维度:总额
	 * 
	 * @param condition
	 * 
	 * @return {id:item, sum:SUM(sum)}
	 * 
	 * @author 延晓磊
	 *
	 * @since 2019年10月19日
	 */
	@Override
	public List<SidCountVo> countSumByItem(Map<String, Object> condition) {
		return countSumByItem(condition, null);
	}
	
	/**
	 * 统计 - 维度:总额
	 * 
	 * @param condition
	 * @param itemMap	维度映射（只返回映射的数据）
	 * 
	 * @return {id:item, name: itemMap[item], sum:SUM(sum)}
	 * 
	 * @author 延晓磊
	 *
	 * @since 2019年10月19日
	 */
	@Override
	public List<SidCountVo> countSumByItem(Map<String, Object> condition, Map<String,String> itemMap) {
		// 分组
		if (condition == null) {
			condition = new HashMap<>();
		}
		condition.put(MapperConstant.ParamName.GROUP_COLUMNS, ReportConstant.Column.ITEM.getGroupColumns());
		// 查询
		List<T> datas = this.chartSum(condition);
		// 整合
		List<SidCountVo> counts = new ArrayList<>();
		SidCountVo count;
		if (MapUtil.isEmpty(itemMap)) {
			// 所有查询结果
			for (T data : datas) {
				count = new SidCountVo();
				count.setId(data.getItem());
				count.setSum(data.getSum());
				counts.add(count);
			}
		}else {
			// 指定映射结果
			for (Entry<String, String> item : itemMap.entrySet()) {
				count = new SidCountVo();
				count.setId(item.getKey());
				count.setName(item.getValue());
				count.setSum(BigDecimal.ZERO);
				for (T data : datas) {
					if (item.getKey().equals(data.getItem())) {
						count.setSum(data.getSum());
						break;
					}
				}
				counts.add(count);
			}
		}
		return counts;
	}
	
	/**
	 * 统计 - 维度:总额
	 * 
	 * @param condition
	 * 
	 * @return {id:item, name:title, sum:SUM(sum)}
	 * 
	 * @author 延晓磊
	 *
	 * @since 2019年10月19日
	 */
	@Override
	public List<SidCountVo> countSumByItemTitle(Map<String, Object> condition) {
		// 分组
		if (condition == null) {
			condition = new HashMap<>();
		}
		condition.put(MapperConstant.ParamName.GROUP_COLUMNS, ReportConstant.Column.ITEM_TITLE.getGroupColumns());
		// 查询
		List<T> datas = this.chartSum(condition);
		// 整合
		List<SidCountVo> counts = new ArrayList<>(datas.size());
		SidCountVo count;
		for (T data : datas) {
			count = new SidCountVo();
			count.setId(data.getItem());
			count.setName(data.getTitle());
			count.setSum(data.getSum());
			counts.add(count);
		}
		return counts;
	}
	
	/**
	 * 统计 - 总数,总额
	 * 
	 * @param condition
	 * 
	 * @return {count:SUM(count), sum:SUM(sum)}
	 * 
	 * @author 延晓磊
	 *
	 * @since 2019年10月19日
	 */
	@Override
	public SidCountSum counts(Map<String, Object> condition) {
		return new SidCountSum(null, countCount(condition), countSum(condition).toPlainString());
	}
	
	/**
	 * 统计 - 维度:总数,总额
	 * 
	 * @param condition
	 * 
	 * @return {id:item, count:SUM(count), sum:SUM(sum)}
	 * 
	 * @author 延晓磊
	 *
	 * @since 2019年10月19日
	 */
	@Override
	public List<SidCountVo> countsByItem(Map<String, Object> condition) {
		return countsByItem(condition, null);
	}
	
	/**
	 * 统计 - 维度:总数,总额
	 * 
	 * @param condition
	 * @param itemMap		维度映射（只返回映射的数据）
	 * 
	 * @return {id:item, name: itemMap[item], count:SUM(count), sum:SUM(sum)}
	 * 
	 * @author 延晓磊
	 *
	 * @since 2019年10月19日
	 */
	@Override
	public List<SidCountVo> countsByItem(Map<String, Object> condition, Map<String,String> itemMap) {
		// 分组
		if (condition == null) {
			condition = new HashMap<>();
		}
		condition.put(MapperConstant.ParamName.GROUP_COLUMNS, ReportConstant.Column.ITEM.getGroupColumns());
		// 查询
		List<T> datas = this.charts(condition);
		// 整合
		List<SidCountVo> counts = new ArrayList<>();
		SidCountVo count;
		if (MapUtil.isEmpty(itemMap)) {
			// 所有查询结果
			for (T data : datas) {
				count = new SidCountVo();
				count.setId(data.getItem());
				count.setCount(data.getCount());
				count.setSum(data.getSum());
				counts.add(count);
			}
		}else {
			// 指定映射结果
			for (Entry<String, String> item : itemMap.entrySet()) {
				count = new SidCountVo();
				count.setId(item.getKey());
				count.setName(item.getValue());
				count.setCount(LongConstant.N0);
				count.setSum(BigDecimal.ZERO);
				for (T data : datas) {
					if (item.getKey().equals(data.getItem())) {
						count.setCount(data.getCount());
						count.setSum(data.getSum());
						break;
					}
				}
				counts.add(count);
			}
		}
		return counts;
	}
	
	/**
	 * 统计 - 维度:总数,总额
	 * 
	 * @param condition
	 * 
	 * @return {id:item, name:title, count:SUM(count), sum:SUM(sum)}
	 * 
	 * @author 延晓磊
	 *
	 * @since 2019年10月19日
	 */
	@Override
	public List<SidCountVo> countsByItemTitle(Map<String, Object> condition) {
		// 分组
		if (condition == null) {
			condition = new HashMap<>();
		}
		condition.put(MapperConstant.ParamName.GROUP_COLUMNS, ReportConstant.Column.ITEM_TITLE.getGroupColumns());
		// 查询
		List<T> datas = this.chartSum(condition);
		// 整合
		List<SidCountVo> counts = new ArrayList<>(datas.size());
		SidCountVo count;
		for (T data : datas) {
			count = new SidCountVo();
			count.setId(data.getItem());
			count.setName(data.getTitle());
			count.setCount(data.getCount());
			count.setSum(data.getSum());
			counts.add(count);
		}
		return counts;
	}
	
	/**
	 * 图表 - 总数
	 * 
	 * @param condition
	 * @return SUM(count)
	 * 
	 * @author 延晓磊
	 *
	 * @since 2019年10月19日
	 */
	@Override
	public List<T> chartCount(Map<String, Object> condition) {
		return getDao().chartCount(condition);
	}

	/**
	 * 图表 - 总额
	 * 
	 * @param condition
	 * @return SUM(sum)
	 * 
	 * @author 延晓磊
	 *
	 * @since 2019年10月19日
	 */
	@Override
	public List<T> chartSum(Map<String, Object> condition) {
		return getDao().chartSum(condition);
	}

	/**
	 * 图表 - 总数,总额
	 * 
	 * @param condition
	 * @return SUM(count),SUM(sum)
	 * 
	 * @author 延晓磊
	 *
	 * @since 2019年10月19日
	 */
	@Override
	public List<T> charts(Map<String, Object> condition) {
		return getDao().charts(condition);
	}

	/**
	 * 分时图表：单维度 count
	 * 
	 * @param mode		模式：ReportConstant.ModeTimeTime
	 * @param date		基准日期：用于查询历史日期的图表，默认当天（时表）、当月（日表）、当年（月表）
	 * @param condition	查询参数：type,item,...
	 * 
	 * @return {category,value}
	 * 
	 * @author 延晓磊
	 *
	 * @since 2019年12月11日
	 */
	@Override
	public ReportDataTimeCount timeChartCount(String mode, ReportTime date, Map<String, Object> condition){
		// 获取图表参数
		ReportParamChartTime param = ReportParamChartTime.build(mode, date);
		// 整合查询参数
		condition = param.getParams(condition);
		// 查询数据
		List<T> list = this.chartCount(condition);
		// 整合图表数据
		return ReportUtil.getTimeChartCount(param, list);
	}
	
	/**
	 * 分时图表：单维度 sum
	 * 
	 * @param mode		模式：ReportConstant.ModeTime
	 * @param date		基准日期：用于查询历史日期的图表，默认当天（时表）、当月（日表）、当年（月表）
	 * @param condition	查询参数：type,item,...
	 * 
	 * @return {category,value}
	 * 
	 * @author 延晓磊
	 *
	 * @since 2019年12月11日
	 */
	@Override
	public ReportDataTimeSum timeChartSum(String mode, ReportTime date, Map<String, Object> condition){
		// 获取图表参数
		ReportParamChartTime param = ReportParamChartTime.build(mode, date);
		// 整合查询参数
		condition = param.getParams(condition);
		// 查询数据
		List<T> list = this.chartSum(condition);
		// 整合图表数据
		return ReportUtil.getTimeChartSum(param, list);
	}
	
	/**
	 * 分时图表：双维度 count,sum
	 * 
	 * @param mode			模式：ReportConstant.ModeTime
	 * @param date			基准日期：用于查询历史日期的图表，默认当天（时表）、当月（日表）、当年（月表）
	 * @param condition		查询参数：type,item,...
	 * @param countTitle	count的维度标题
	 * @param sumTitle		sum的维度标题
	 * 
	 * @return {category,value,legend[countTitle,sumTitle]}
	 * 
	 * @author 延晓磊
	 *
	 * @since 2019年12月11日
	 */
	@Override
	public ReportDataTimeCountSum timeCharts(String mode, ReportTime date, Map<String, Object> condition, String countTitle, String sumTitle){
		// 参数校验
		ParamEmptyUtil.checkBlank(countTitle, sumTitle);
		// 获取图表参数
		ReportParamChartTime param = ReportParamChartTime.build(mode, date);
		// 整合查询参数
		condition = param.getParams(condition);
		// 查询数据
		List<T> list = this.charts(condition);
		// 整合图表数据
		return ReportUtil.getTimeChartCountSum(param, list, countTitle, sumTitle);
	}
	
	/**
	 * 分时图表：多维度 count
	 * 
	 * @param mode		模式：ReportConstant.ModeTime
	 * @param date		基准日期：用于查询历史日期的图表，默认当天（时表）、当月（日表）、当年（月表）
	 * @param condition	查询参数：type,item,...
	 * @param items		维度映射：{item:title}，如果为空则获取{data.item:data.title}
	 * 
	 * @return {category,value,legend[title]}
	 * 
	 * @author 延晓磊
	 *
	 * @since 2019年12月11日
	 */
	@Override
	public ReportDataTimeCounts timeChartCounts(String mode, ReportTime date, Map<String, Object> condition, Map<String, String> items){
		// 获取图表参数
		ReportParamChartTime param = ReportParamChartTime.build(mode, date, true, MapUtil.isEmpty(items));
		// 整合查询参数
		condition = param.getParams(condition);
		// 查询数据
		List<T> list = this.chartCount(condition);
		// 整合图表数据
		return ReportUtil.getTimeChartCounts(param, list, items);
	}
	
	/**
	 * 分时图表：多维度 sum
	 * 
	 * @param mode		模式：ReportConstant.ModeTime
	 * @param date		基准日期：用于查询历史日期的图表，默认当天（时表）、当月（日表）、当年（月表）
	 * @param condition	查询参数：type,item,...
	 * @param items		维度映射：{item:title}，如果为空则获取{data.item:data.title}
	 * 
	 * @return {category,value,legend[title]}
	 * 
	 * @author 延晓磊
	 *
	 * @since 2019年12月11日
	 */
	@Override
	public ReportDataTimeSums timeChartSums(String mode, ReportTime date, Map<String, Object> condition, Map<String, String> items){
		// 获取图表参数
		ReportParamChartTime param = ReportParamChartTime.build(mode, date, true, MapUtil.isEmpty(items));
		// 整合查询参数
		condition = param.getParams(condition);
		// 查询数据
		List<T> list = this.chartSum(condition);
		// 整合图表数据
		return ReportUtil.getTimeChartSums(param, list, items);
	}
	
	/**
	 * 分时图表：多维度 count
	 * 
	 * @param mode		模式：ReportConstant.ModeTime
	 * @param date		基准日期：用于查询历史日期的图表，默认当天（时表）、当月（日表）、当年（月表）
	 * @param condition	查询参数：type,item,...
	 * @param items		维度列表：[item]，如果为空则获取[data.item]
	 * 
	 * @return {category,value,legend[item]}
	 * 
	 * @author 延晓磊
	 *
	 * @since 2019年12月11日
	 */
	@Override
	public ReportDataTimeCounts timeChartCounts2(String mode, ReportTime date, Map<String, Object> condition, List<String> items){
		// 获取图表参数
		ReportParamChartTime param = ReportParamChartTime.buildMulit(mode, date);
		// 整合查询参数
		condition = param.getParams(condition);
		// 查询数据
		List<T> list = this.chartCount(condition);
		// 整合图表数据
		return ReportUtil.getTimeChartCounts2(param, list, items);
	}
	
	/**
	 * 分时图表：多维度 sum
	 * 
	 * @param mode		模式：ReportConstant.ModeTime
	 * @param date		基准日期：用于查询历史日期的图表，默认当天（时表）、当月（日表）、当年（月表）
	 * @param condition	查询参数：type,item,...
	 * @param items		维度列表：[item]，如果为空则获取[data.item]
	 * 
	 * @return {category,value,legend[item]}
	 * 
	 * @author 延晓磊
	 *
	 * @since 2019年12月11日
	 */
	@Override
	public ReportDataTimeSums timeChartSums2(String mode, ReportTime date, Map<String, Object> condition, List<String> items){
		// 获取图表参数
		ReportParamChartTime param = ReportParamChartTime.buildMulit(mode, date);
		// 整合查询参数
		condition = param.getParams(condition);
		// 查询数据
		List<T> list = this.chartSum(condition);
		// 整合图表数据
		return ReportUtil.getTimeChartSums2(param, list, items);
	}
	
	/**
	 * 周期图表：单维度 count
	 * 
	 * @param mode		模式：ReportConstant.ModePeriod
	 * @param num		周期数
	 * @param date		基准日期(结束周期)，默认当前
	 * @param condition	查询参数：type,item,...
	 * 
	 * @return {category,value}
	 * 
	 * @author 延晓磊
	 *
	 * @since 2019年12月11日
	 */
	@Override
	public ReportDataPeriodCount periodChartCount(String mode, Integer num, LocalDateTime date, Map<String, Object> condition){
		// 获取图表参数
		ReportParamChartPeriod param = ReportParamChartPeriod.build(mode, num, date);
		// 整合查询参数
		condition = param.getParams(condition);
		// 查询数据
		List<T> list = this.chartCount(condition);
		// 整合图表数据
		return ReportUtil.getPeriodChartCount(param, list);
	}
	
	/**
	 * 周期图表：单维度 sum
	 * 
	 * @param mode		模式：ReportConstant.ModePeriod
	 * @param num		周期数
	 * @param date		基准日期(结束周期)，默认当前
	 * @param condition	查询参数：type,item,...
	 * 
	 * @return {category,value}
	 * 
	 * @author 延晓磊
	 *
	 * @since 2019年12月11日
	 */
	@Override
	public ReportDataPeriodSum periodChartSum(String mode, Integer num, LocalDateTime date, Map<String, Object> condition){
		// 获取图表参数
		ReportParamChartPeriod param = ReportParamChartPeriod.build(mode, num, date);
		// 整合查询参数
		condition = param.getParams(condition);
		// 查询数据
		List<T> list = this.chartSum(condition);
		// 整合图表数据
		return ReportUtil.getPeriodChartSum(param, list);
	}
	
	/**
	 * 周期图表：双维度 count,sum
	 * 
	 * @param mode			模式：ReportConstant.ModePeriod
	 * @param num			周期数
	 * @param date			基准日期(结束周期)，默认当前
	 * @param condition		查询参数：type,item,...
	 * @param countTitle	count的维度标题
	 * @param sumTitle		sum的维度标题
	 * 
	 * @return {category,value,legend[countTitle,sumTitle]}
	 * 
	 * @author 延晓磊
	 *
	 * @since 2019年12月11日
	 */
	@Override
	public ReportDataPeriodCountSum periodCharts(String mode, Integer num, LocalDateTime date, Map<String, Object> condition, String countTitle, String sumTitle){
		// 参数校验
		ParamEmptyUtil.checkBlank(countTitle, sumTitle);
		// 获取图表参数
		ReportParamChartPeriod param = ReportParamChartPeriod.build(mode, num, date);
		// 整合查询参数
		condition = param.getParams(condition);
		// 查询数据
		List<T> list = this.charts(condition);
		// 整合图表数据
		return ReportUtil.getPeriodChartCountSum(param, list, countTitle, sumTitle);
	}
	
	/**
	 * 周期图表：多维度 count
	 * 
	 * @param mode		模式：ReportConstant.ModePeriod
	 * @param num		周期数
	 * @param date		基准日期(结束周期)，默认当前
	 * @param condition	查询参数：type,item,...
	 * @param items		维度映射：{item:title}，如果为空则获取{data.item:data.title}
	 * 
	 * @return {category,value,legend[title]}
	 * 
	 * @author 延晓磊
	 *
	 * @since 2019年12月11日
	 */
	@Override
	public ReportDataPeriodCounts periodChartCounts(String mode, Integer num, LocalDateTime date, Map<String, Object> condition, Map<String, String> items){
		// 获取图表参数
		ReportParamChartPeriod param = ReportParamChartPeriod.build(mode, num, date, true, MapUtil.isEmpty(items));
		// 整合查询参数
		condition = param.getParams(condition);
		// 查询数据
		List<T> list = this.chartCount(condition);
		// 整合图表数据
		return ReportUtil.getPeriodChartCounts(param, list, items);
	}
	
	/**
	 * 周期图表：多维度 sum
	 * 
	 * @param mode		模式：ReportConstant.ModePeriod
	 * @param num		周期数
	 * @param date		基准日期(结束周期)，默认当前
	 * @param condition	查询参数：type,item,...
	 * @param items		维度映射：{item:title}，如果为空则获取{data.item:data.title}
	 * 
	 * @return {category,value,legend[title]}
	 * 
	 * @author 延晓磊
	 *
	 * @since 2019年12月11日
	 */
	@Override
	public ReportDataPeriodSums periodChartSums(String mode, Integer num, LocalDateTime date, Map<String, Object> condition, Map<String, String> items){
		// 获取图表参数
		ReportParamChartPeriod param = ReportParamChartPeriod.build(mode, num, date, true, MapUtil.isEmpty(items));
		// 整合查询参数
		condition = param.getParams(condition);
		// 查询数据
		List<T> list = this.chartSum(condition);
		// 整合图表数据
		return ReportUtil.getPeriodChartSums(param, list, items);
	}
	
	/**
	 * 周期图表：多维度 count
	 * 
	 * @param mode		模式：ReportConstant.ModePeriod
	 * @param num		周期数
	 * @param date		基准日期(结束周期)，默认当前
	 * @param condition	查询参数：type,item,...
	 * @param items		维度列表：[item]，如果为空则获取[data.item]
	 * 
	 * @return {category,value,legend[item]}
	 * 
	 * @author 延晓磊
	 *
	 * @since 2019年12月11日
	 */
	@Override
	public ReportDataPeriodCounts periodChartCounts2(String mode, Integer num, LocalDateTime date, Map<String, Object> condition, List<String> items){
		// 获取图表参数
		ReportParamChartPeriod param = ReportParamChartPeriod.buildMulit(mode, num, date);
		// 整合查询参数
		condition = param.getParams(condition);
		// 查询数据
		List<T> list = this.chartCount(condition);
		// 整合图表数据
		return ReportUtil.getPeriodChartCounts2(param, list, items);
	}
	
	/**
	 * 周期图表：多维度 sum
	 * 
	 * @param mode		模式：ReportConstant.ModePeriod
	 * @param num		周期数
	 * @param date		基准日期(结束周期)，默认当前
	 * @param condition	查询参数：type,item,...
	 * @param items		维度列表：[item]，如果为空则获取[data.item]
	 * 
	 * @return {category,value,legend[item]}
	 * 
	 * @author 延晓磊
	 *
	 * @since 2019年12月11日
	 */
	@Override
	public ReportDataPeriodSums periodChartSums2(String mode, Integer num, LocalDateTime date, Map<String, Object> condition, List<String> items){
		// 获取图表参数
		ReportParamChartPeriod param = ReportParamChartPeriod.buildMulit(mode, num, date);
		// 整合查询参数
		condition = param.getParams(condition);
		// 查询数据
		List<T> list = this.chartSum(condition);
		// 整合图表数据
		return ReportUtil.getPeriodChartSums2(param, list, items);
	}
	
	/**
	 * 整合Count
	 * 
	 * @param mode		模式：ReportConstant.CountMode
	 * @param condition	查询条件
	 * @param itemMap	维度映射（只返回映射的数据）
	 * 
	 * @return 统计数据/维度列表
	 * 
	 * @author 延晓磊
	 *
	 * @since 2019年12月12日
	 */
	@Override
	public Result counts(String mode, Map<String, Object> condition, Map<String, String> itemMap) {
		// 参数校验
		ParamEmptyUtil.checkBlank(mode);
		// 模式
		switch (mode) {
		case ReportConstant.CountMode.COUNT:
			return Result.successNum(countCount(condition));
		case ReportConstant.CountMode.COUNT_ITEM:
			return Result.successList(countCountByItem(condition, itemMap));
		case ReportConstant.CountMode.COUNT_ITEM_TITLE:
			return Result.successList(countCountByItemTitle(condition));
		case ReportConstant.CountMode.SUM:
			return Result.successNum(countSum(condition));
		case ReportConstant.CountMode.SUM_ITEM:
			return Result.successList(countSumByItem(condition, itemMap));
		case ReportConstant.CountMode.SUM_ITEM_TITLE:
			return Result.successList(countSumByItemTitle(condition));
		case ReportConstant.CountMode.COUNT_SUM:
			return Result.success(counts(condition));
		case ReportConstant.CountMode.COUNT_SUM_ITEM:
			return Result.successList(countsByItem(condition, itemMap));
		case ReportConstant.CountMode.COUNT_SUM_ITEM_TITLE:
			return Result.successList(countsByItemTitle(condition));
		default:
			throw ReportConstant.CHART_MODE_ERROR;
		}
	}
	
	/**
	 * 整合Charts
	 * 
	 * @param fullMode		完整模式，由3位整数组成：2位模式ReportConstant.ModeTime/ModePeriod + 1位维度Dimension
	 * @param condition		查询条件
	 * @param date			分时图表的基准日期：用于查询历史日期的图表，默认当天（时表）、当月（日表）、当年（月表）
	 * @param num			周期图表的周期数
	 * @param endDate		周期图表的截止日期：用于判断结束周期，默认当前
	 * @param countTitle	双维度：count的维度标题
	 * @param sumTitle		双维度：sum的维度标题
	 * @param itemMap		多维度映射：{item, title}，如果为空则获取{data.item:data.title}
	 * @param itemList		多维度列表：[item]，如果为空则获取[data.item]
	 * @param itemType		多维度类型：非空优先，都为空则true itemMap, false itemList
	 * 
	 * @return 单维度{category,value}，双维度{category,value,legend[countTitle,sumTitle]}，多维度{category,value,legend[item]}、{category,value,legend[title]}
	 * 
	 * @author 延晓磊
	 *
	 * @since 2019年12月12日
	 */
	@Override
	public Result charts(String fullMode, Map<String, Object> condition, 
			ReportTime date, 
			Integer num, LocalDateTime endDate, 
			String countTitle, String sumTitle, 
			Map<String, String> itemMap, List<String> itemList, boolean itemType) {
		// 参数校验
		ParamEmptyUtil.checkBlank(fullMode);
		ParamValidUtil.assertCheck(ReportConstant.CHARTS_MODE_ERROR_MSG, fullMode.length() == 3);
		// 模式,维度
		String modeType = fullMode.substring(0,1);
		String mode = fullMode.substring(0,2);
		String dimension = fullMode.substring(2,3);
		if (ModeTime.MODE_TYPE.equals(modeType)) {
			// 分时图表
			switch (dimension) {
			case Dimension.COUNT:
				// count
				return Result.success(timeChartCount(mode, date, condition));
			case Dimension.SUM:
				// sum
				return Result.success(timeChartSum(mode, date, condition));
			case Dimension.COUNT_SUM:
				// 双维 count + sum
				return Result.success(timeCharts(mode, date, condition, countTitle, sumTitle));
			case Dimension.COUNTS:
				// 多维 count
				if (MapUtil.isNotEmpty(itemMap)) {
					// 优先 item:title
					return Result.success(timeChartCounts(mode, date, condition, itemMap));
				}else if (CollectionUtils.isNotEmpty(itemList)) {
					// 其次 item
					return Result.success(timeChartCounts2(mode, date, condition, itemList));
				}else {
					// 数据中获取
					if (itemType) {
						return Result.success(timeChartCounts(mode, date, condition, null));
					} else {
						return Result.success(timeChartCounts2(mode, date, condition, null));
					}
				}
			case Dimension.SUMS:
				// 多维 sum
				if (MapUtil.isNotEmpty(itemMap)) {
					// 优先 item:title
					return Result.success(timeChartSums(mode, date, condition, itemMap));
				}else if (CollectionUtils.isNotEmpty(itemList)) {
					// 其次 item
					return Result.success(timeChartSums2(mode, date, condition, itemList));
				}else {
					// 数据中获取
					if (itemType) {
						return Result.success(timeChartSums(mode, date, condition, null));
					} else {
						return Result.success(timeChartSums2(mode, date, condition, null));
					}
				}
			default:
				return Result.error(ReportConstant.CHARTS_MODE_ERROR_MSG);
			}
		}else if (ModePeriod.MODE_TPYE.equals(modeType)) {
			// 周期图表
			switch (dimension) {
			case Dimension.COUNT:
				// count
				return Result.success(periodChartCount(mode, num, endDate, condition));
			case Dimension.SUM:
				// sum
				return Result.success(periodChartSum(mode, num, endDate, condition));
			case Dimension.COUNT_SUM:
				// 双维 count + sum
				return Result.success(periodCharts(mode, num, endDate, condition, countTitle, sumTitle));
			case Dimension.COUNTS:
				// 多维 count
				if (MapUtil.isNotEmpty(itemMap)) {
					// 优先 item:title
					return Result.success(periodChartCounts(mode, num, endDate, condition, itemMap));
				}else if (CollectionUtils.isNotEmpty(itemList)) {
					// 其次 item
					return Result.success(periodChartCounts2(mode, num, endDate, condition, itemList));
				}else {
					// 数据中获取
					if (itemType) {
						return Result.success(periodChartCounts(mode, num, endDate, condition, null));
					} else {
						return Result.success(periodChartCounts2(mode, num, endDate, condition, null));
					}
				}
			case Dimension.SUMS:
				// 多维 sum
				if (MapUtil.isNotEmpty(itemMap)) {
					// 优先 item:title
					return Result.success(periodChartSums(mode, num, endDate, condition, itemMap));
				}else if (CollectionUtils.isNotEmpty(itemList)) {
					// 其次 item
					return Result.success(periodChartSums2(mode, num, endDate, condition, itemList));
				}else {
					// 数据中获取
					if (itemType) {
						return Result.success(periodChartSums(mode, num, endDate, condition, null));
					} else {
						return Result.success(periodChartSums2(mode, num, endDate, condition, null));
					}
				}
			default:
				return Result.error(ReportConstant.CHARTS_MODE_ERROR_MSG);
			}
		}else {
			return Result.error(ReportConstant.CHARTS_MODE_ERROR_MSG);
		}
	}
	
	/**
	 * 统计图表：整合报表的counts/charts
	 * 
	 * @param param		报表统计参数
	 * @param condition	数据筛选参数
	 * @return
	 * 
	 * @author 延晓磊
	 *
	 * @since 2019年12月12日
	 */
	@Override
	public Result countCharts(ReportParam param, Map<String, Object> condition) {
		// 筛选报表数据
		if (condition == null) {
			condition = new HashMap<>();
		}
		if (StringUtils.isNotBlank(param.getType())) {
			condition.put("type", param.getType());
		}
		if (StringUtils.isNotBlank(param.getItem())) {
			condition.put("item", param.getItem());
		}
		// 查询报表
		if (StringConstant.N1.equals(param.getMethod())) {
			// Counts统计
			if (StringUtils.isNotBlank(param.getStartTime())) {
				condition.put(MapperConstant.ParamName.START_TIME, param.getStartTime());
			}
			if (StringUtils.isNotBlank(param.getEndTime())) {
				condition.put(MapperConstant.ParamName.END_TIME, param.getEndTime());
			}
			return counts(param.getMode(), condition, param.getItemMap());
		}else {
			// Charts图表
			return charts(param.getMode(), condition, new ReportTime(param), param.getNum(), param.getDate(), param.getCountTitle(), param.getSumTitle(), param.getItemMap(), param.getItemList(), Common.YES.equals(param.getItemAuto()));
		}
	}
	
	/**
	 * 统计图表：整合报表的counts/charts
	 * 
	 * @param param		报表统计参数
	 * @return
	 * 
	 * @author 延晓磊
	 *
	 * @since 2019年12月12日
	 */
	@Override
	public Result countCharts(ReportParam param) {
		return countCharts(param, null);
	}
}
